Crate r2r

Easy to use, runtime-agnostic async rust bindings for ROS2.

Minimal bindings for ROS2 that do not require hooking in to the ROS2 build infrastructure – cargo build is all you need. Convenience Rust types are created by calling into the c introspection libraries. This circumvents the ROS2 .msg/.idl pipeline by relying on already generated C code. By default, the behavior is to build bindings to the RCL and all message types that can be found in the currently sourced ros environment.

What works?

• Up to date with ROS2 Dashing Eloquent Foxy Galactic Humble
• Building Rust types
• Publish/subscribe
• Services
• Actions
• Parameter handling

---

After having sourced ROS2 (see README for more details), you can try the following example:

use futures::executor::LocalPool;
use futures::future;
use futures::stream::StreamExt;
use futures::task::LocalSpawnExt;
use r2r::QosProfile;

fn main() -> Result<(), Box<dyn std::error::Error>> {
   let ctx = r2r::Context::create()?;
   let mut node = r2r::Node::create(ctx, "node", "namespace")?;
   let subscriber = node.subscribe::<r2r::std_msgs::msg::String>("/topic", QosProfile::default())?;
   let publisher = node.create_publisher::<r2r::std_msgs::msg::String>("/topic", QosProfile::default())?;
   let mut timer = node.create_wall_timer(std::time::Duration::from_millis(1000))?;

   // Set up a simple task executor.
   let mut pool = LocalPool::new();
   let spawner = pool.spawner();

   // Run the subscriber in one task, printing the messages
   spawner.spawn_local(async move {
       subscriber.for_each(|msg| {
           println!("got new msg: {}", msg.data);
           future::ready(())
       }).await
   })?;

   // Run the publisher in another task
   spawner.spawn_local(async move {
       let mut counter = 0;
       loop {
           let _elapsed = timer.tick().await.unwrap();
           let msg = r2r::std_msgs::msg::String { data: format!("Hello, world! ({})", counter) };
           publisher.publish(&msg).unwrap();
           counter += 1;
       }
   })?;

   // Main loop spins ros.
   loop {
       node.spin_once(std::time::Duration::from_millis(100));
       pool.run_until_stalled();
   }
}

Re-exports

• pub extern crate uuid;
• pub use qos::QosProfile;

Modules

• action_msgs
• builtin_interfaces
• diagnostic_msgs
• geometry_msgs
• lifecycle_msgs
• nav_msgs
• qos
  QoS (Quality of Service) full credit goes to https://github.com/rclrust/rclrust/blob/main/rclrust/src/qos.rs
• rcl_interfaces
• rosgraph_msgs
• sensor_msgs
• shape_msgs
• statistics_msgs
• std_msgs
• stereo_msgs
• test_msgs
• tf2_msgs
• trajectory_msgs
• unique_identifier_msgs
• visualization_msgs

Macros

• log_debug
  Debug log message.
• log_error
  Error log message.
• log_fatal
  Fatal log message.
• log_info
  Info log message.
• log_warn
  Warning log message.

Structs

• ActionClient
  Action client
• ActionClientGoal
  Action client goal handle
• ActionClientGoalUntyped
  Action client goal handle (untyped)
• ActionClientUntyped
  Action client (untyped)
• ActionServerCancelRequest
  Request to cancel an active goal.
• ActionServerGoal
  A handle to an active Goal
• ActionServerGoalRequest
  Request to the action server to accept a new Goal.
• Client
  ROS service client.
• ClientUntyped
  ROS “untyped” service client.
• Clock
  A ROS clock.
• Context
  A ROS context. Needed to create nodes etc.
• NativeMsg
  This struct wraps a RCL message.
• Node
  A ROS Node.
• Parameter
  ROS parameter.
• Publisher
  A ROS (typed) publisher.
• PublisherUntyped
  A ROS (untyped) publisher.
• ServiceRequest
  Encapsulates a service request.
• Timer
  A ROS timer.
• WrappedNativeMsgUntyped

Enums

• ClockType
  Different ROS clock types.
• Error
  r2r Error type.
• GoalStatus
  The status of a goal.
• LogSeverity
  Logging severity
• ParameterValue
  ROS parameter value.

Constants

• ROS_DISTRO

Traits

• RosParams
  Trait for use it with Node::make_derived_parameter_handler().
• WrappedActionTypeSupport
• WrappedServiceTypeSupport
• WrappedTypesupport

Type Aliases

• Result
  r2r Result type.

Derive Macros

• RosParams
  Derives RosParams trait for a structure to use it with r2r::Node::make_derived_parameter_handler().